Three-dimension (3D) graphics applications generate image frames by combining input textures, lighting model and physics model. The image generation is intensive in both the number of computes required to do the lighting and physics but also in the number of memory operations for fetching the input textures and writing out processed pixels. Since the performance and power consumption is typically dependent on the number of memory operations, graphics hardware implementations optimize to reduce the number of memory operations. One of common 3D graphics operations that is optimized is the operation of clearing the framebuffer since applications typically start any rendering operation sequence by starting with a clear framebuffer.
The clear operation can be very time consuming and wasteful of system resource such as memory operations since the clear operation is expected to touch every pixel in the framebuffer. Graphics processor implementations can optimize the clear operation by delaying the activity of touching any pixel by tracking what pixels have been over-written. If a cleared pixel is overwritten, then the pixel starts with the overwritten value and the clear operation for the pixel is suppressed. However, if a pixel is not-overwritten and has a clear color value, such a pixel when used for subsequent operations can continue to further provide for reduced number of memory operations. If such a clear pixel is to be displayed, instead of fetching the data from the framebuffer, the clear color value can be substituted for such pixels by the display hardware. In essence, optimizing for clear color has benefit of reduced memory operation not just for the initial clear but any subsequent operations that reference such a pixel. However, known hardware solutions optimize only when the framebuffer is explicitly cleared by the application by making an explicit request to clear to the framebuffer.